home *** CD-ROM | disk | FTP | other *** search
/ Champak 145 / (Vol 145) Dec 21 2011.iso / Games / hanna-in-a-choppa.swf / scripts / __Packages / com / mosesSupposes / fuse / PennerEasing.as < prev    next >
Encoding:
Text File  |  2011-12-21  |  9.2 KB  |  366 lines
  1. class com.mosesSupposes.fuse.PennerEasing
  2. {
  3.    static var registryKey = "pennerEasing";
  4.    function PennerEasing()
  5.    {
  6.    }
  7.    static function linear(t, b, c, d)
  8.    {
  9.       return c * t / d + b;
  10.    }
  11.    static function easeInQuad(t, b, c, d)
  12.    {
  13.       return c * (t /= d) * t + b;
  14.    }
  15.    static function easeOutQuad(t, b, c, d)
  16.    {
  17.       return (- c) * (t /= d) * (t - 2) + b;
  18.    }
  19.    static function easeInOutQuad(t, b, c, d)
  20.    {
  21.       if((t /= d / 2) < 1)
  22.       {
  23.          return c / 2 * t * t + b;
  24.       }
  25.       return (- c) / 2 * ((t = t - 1) * (t - 2) - 1) + b;
  26.    }
  27.    static function easeInExpo(t, b, c, d)
  28.    {
  29.       return t != 0 ? c * Math.pow(2,10 * (t / d - 1)) + b : b;
  30.    }
  31.    static function easeOutExpo(t, b, c, d)
  32.    {
  33.       return t != d ? c * (- Math.pow(2,-10 * t / d) + 1) + b : b + c;
  34.    }
  35.    static function easeInOutExpo(t, b, c, d)
  36.    {
  37.       if(t == 0)
  38.       {
  39.          return b;
  40.       }
  41.       if(t == d)
  42.       {
  43.          return b + c;
  44.       }
  45.       if((t /= d / 2) < 1)
  46.       {
  47.          return c / 2 * Math.pow(2,10 * (t - 1)) + b;
  48.       }
  49.       return c / 2 * (- Math.pow(2,-10 * (t = t - 1)) + 2) + b;
  50.    }
  51.    static function easeOutInExpo(t, b, c, d)
  52.    {
  53.       if(t == 0)
  54.       {
  55.          return b;
  56.       }
  57.       if(t == d)
  58.       {
  59.          return b + c;
  60.       }
  61.       if((t /= d / 2) < 1)
  62.       {
  63.          return c / 2 * (- Math.pow(2,-10 * t) + 1) + b;
  64.       }
  65.       return c / 2 * (Math.pow(2,10 * (t - 2)) + 1) + b;
  66.    }
  67.    static function easeInElastic(t, b, c, d, a, p)
  68.    {
  69.       var _loc5_ = undefined;
  70.       if(t == 0)
  71.       {
  72.          return b;
  73.       }
  74.       if((t /= d) == 1)
  75.       {
  76.          return b + c;
  77.       }
  78.       if(!p)
  79.       {
  80.          p = d * 0.3;
  81.       }
  82.       if(!a || a < Math.abs(c))
  83.       {
  84.          a = c;
  85.          _loc5_ = p / 4;
  86.       }
  87.       else
  88.       {
  89.          _loc5_ = p / 6.283185307179586 * Math.asin(c / a);
  90.       }
  91.       return - a * Math.pow(2,10 * (t -= 1)) * Math.sin((t * d - _loc5_) * 6.283185307179586 / p) + b;
  92.    }
  93.    static function easeOutElastic(t, b, c, d, a, p)
  94.    {
  95.       var _loc5_ = undefined;
  96.       if(t == 0)
  97.       {
  98.          return b;
  99.       }
  100.       if((t /= d) == 1)
  101.       {
  102.          return b + c;
  103.       }
  104.       if(!p)
  105.       {
  106.          p = d * 0.3;
  107.       }
  108.       if(!a || a < Math.abs(c))
  109.       {
  110.          a = c;
  111.          _loc5_ = p / 4;
  112.       }
  113.       else
  114.       {
  115.          _loc5_ = p / 6.283185307179586 * Math.asin(c / a);
  116.       }
  117.       return a * Math.pow(2,-10 * t) * Math.sin((t * d - _loc5_) * 6.283185307179586 / p) + c + b;
  118.    }
  119.    static function easeInOutElastic(t, b, c, d, a, p)
  120.    {
  121.       var _loc5_ = undefined;
  122.       if(t == 0)
  123.       {
  124.          return b;
  125.       }
  126.       if((t /= d / 2) == 2)
  127.       {
  128.          return b + c;
  129.       }
  130.       if(!p)
  131.       {
  132.          p = d * 0.44999999999999996;
  133.       }
  134.       if(!a || a < Math.abs(c))
  135.       {
  136.          a = c;
  137.          _loc5_ = p / 4;
  138.       }
  139.       else
  140.       {
  141.          _loc5_ = p / 6.283185307179586 * Math.asin(c / a);
  142.       }
  143.       if(t < 1)
  144.       {
  145.          return -0.5 * (a * Math.pow(2,10 * (t -= 1)) * Math.sin((t * d - _loc5_) * 6.283185307179586 / p)) + b;
  146.       }
  147.       return a * Math.pow(2,-10 * (t -= 1)) * Math.sin((t * d - _loc5_) * 6.283185307179586 / p) * 0.5 + c + b;
  148.    }
  149.    static function easeOutInElastic(t, b, c, d, a, p)
  150.    {
  151.       var _loc5_ = undefined;
  152.       if(t == 0)
  153.       {
  154.          return b;
  155.       }
  156.       if((t /= d / 2) == 2)
  157.       {
  158.          return b + c;
  159.       }
  160.       if(!p)
  161.       {
  162.          p = d * 0.44999999999999996;
  163.       }
  164.       if(!a || a < Math.abs(c))
  165.       {
  166.          a = c;
  167.          _loc5_ = p / 4;
  168.       }
  169.       else
  170.       {
  171.          _loc5_ = p / 6.283185307179586 * Math.asin(c / a);
  172.       }
  173.       if(t < 1)
  174.       {
  175.          return 0.5 * (a * Math.pow(2,-10 * t) * Math.sin((t * d - _loc5_) * 6.283185307179586 / p)) + c / 2 + b;
  176.       }
  177.       return c / 2 + 0.5 * (a * Math.pow(2,10 * (t - 2)) * Math.sin((t * d - _loc5_) * 6.283185307179586 / p)) + b;
  178.    }
  179.    static function easeInBack(t, b, c, d, s)
  180.    {
  181.       if(s == undefined)
  182.       {
  183.          s = 1.70158;
  184.       }
  185.       return c * (t /= d) * t * ((s + 1) * t - s) + b;
  186.    }
  187.    static function easeOutBack(t, b, c, d, s)
  188.    {
  189.       if(s == undefined)
  190.       {
  191.          s = 1.70158;
  192.       }
  193.       return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
  194.    }
  195.    static function easeInOutBack(t, b, c, d, s)
  196.    {
  197.       if(s == undefined)
  198.       {
  199.          s = 1.70158;
  200.       }
  201.       if((t /= d / 2) < 1)
  202.       {
  203.          return c / 2 * (t * t * (((s *= 1.525) + 1) * t - s)) + b;
  204.       }
  205.       return c / 2 * ((t -= 2) * t * (((s *= 1.525) + 1) * t + s) + 2) + b;
  206.    }
  207.    static function easeOutInBack(t, b, c, d, s)
  208.    {
  209.       if(s == undefined)
  210.       {
  211.          s = 1.70158;
  212.       }
  213.       if((t /= d / 2) < 1)
  214.       {
  215.          return c / 2 * ((t = t - 1) * t * (((s *= 1.525) + 1) * t + s) + 1) + b;
  216.       }
  217.       return c / 2 * ((t = t - 1) * t * (((s *= 1.525) + 1) * t - s) + 1) + b;
  218.    }
  219.    static function easeOutBounce(t, b, c, d)
  220.    {
  221.       if((t /= d) < 0.36363636363636365)
  222.       {
  223.          return c * (7.5625 * t * t) + b;
  224.       }
  225.       if(t < 0.7272727272727273)
  226.       {
  227.          return c * (7.5625 * (t -= 0.5454545454545454) * t + 0.75) + b;
  228.       }
  229.       if(t < 0.9090909090909091)
  230.       {
  231.          return c * (7.5625 * (t -= 0.8181818181818182) * t + 0.9375) + b;
  232.       }
  233.       return c * (7.5625 * (t -= 0.9545454545454546) * t + 0.984375) + b;
  234.    }
  235.    static function easeInBounce(t, b, c, d)
  236.    {
  237.       return c - com.mosesSupposes.fuse.PennerEasing.easeOutBounce(d - t,0,c,d) + b;
  238.    }
  239.    static function easeInOutBounce(t, b, c, d)
  240.    {
  241.       if(t < d / 2)
  242.       {
  243.          return com.mosesSupposes.fuse.PennerEasing.easeInBounce(t * 2,0,c,d) * 0.5 + b;
  244.       }
  245.       return com.mosesSupposes.fuse.PennerEasing.easeOutBounce(t * 2 - d,0,c,d) * 0.5 + c * 0.5 + b;
  246.    }
  247.    static function easeOutInBounce(t, b, c, d)
  248.    {
  249.       if(t < d / 2)
  250.       {
  251.          return com.mosesSupposes.fuse.PennerEasing.easeOutBounce(t * 2,0,c,d) * 0.5 + b;
  252.       }
  253.       return com.mosesSupposes.fuse.PennerEasing.easeInBounce(t * 2 - d,0,c,d) * 0.5 + c * 0.5 + b;
  254.    }
  255.    static function easeInCubic(t, b, c, d)
  256.    {
  257.       return c * (t /= d) * t * t + b;
  258.    }
  259.    static function easeOutCubic(t, b, c, d)
  260.    {
  261.       return c * ((t = t / d - 1) * t * t + 1) + b;
  262.    }
  263.    static function easeInOutCubic(t, b, c, d)
  264.    {
  265.       if((t /= d / 2) < 1)
  266.       {
  267.          return c / 2 * t * t * t + b;
  268.       }
  269.       return c / 2 * ((t -= 2) * t * t + 2) + b;
  270.    }
  271.    static function easeOutInCubic(t, b, c, d)
  272.    {
  273.       t /= d / 2;
  274.       return c / 2 * ((t = t - 1) * t * t + 1) + b;
  275.    }
  276.    static function easeInQuart(t, b, c, d)
  277.    {
  278.       return c * (t /= d) * t * t * t + b;
  279.    }
  280.    static function easeOutQuart(t, b, c, d)
  281.    {
  282.       return (- c) * ((t = t / d - 1) * t * t * t - 1) + b;
  283.    }
  284.    static function easeInOutQuart(t, b, c, d)
  285.    {
  286.       if((t /= d / 2) < 1)
  287.       {
  288.          return c / 2 * t * t * t * t + b;
  289.       }
  290.       return (- c) / 2 * ((t -= 2) * t * t * t - 2) + b;
  291.    }
  292.    static function easeOutInQuart(t, b, c, d)
  293.    {
  294.       if((t /= d / 2) < 1)
  295.       {
  296.          return (- c) / 2 * ((t = t - 1) * t * t * t - 1) + b;
  297.       }
  298.       return c / 2 * ((t = t - 1) * t * t * t + 1) + b;
  299.    }
  300.    static function easeInQuint(t, b, c, d)
  301.    {
  302.       return c * (t /= d) * t * t * t * t + b;
  303.    }
  304.    static function easeOutQuint(t, b, c, d)
  305.    {
  306.       return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
  307.    }
  308.    static function easeInOutQuint(t, b, c, d)
  309.    {
  310.       if((t /= d / 2) < 1)
  311.       {
  312.          return c / 2 * t * t * t * t * t + b;
  313.       }
  314.       return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
  315.    }
  316.    static function easeOutInQuint(t, b, c, d)
  317.    {
  318.       t /= d / 2;
  319.       return c / 2 * ((t = t - 1) * t * t * t * t + 1) + b;
  320.    }
  321.    static function easeInSine(t, b, c, d)
  322.    {
  323.       return (- c) * Math.cos(t / d * 1.5707963267948966) + c + b;
  324.    }
  325.    static function easeOutSine(t, b, c, d)
  326.    {
  327.       return c * Math.sin(t / d * 1.5707963267948966) + b;
  328.    }
  329.    static function easeInOutSine(t, b, c, d)
  330.    {
  331.       return (- c) / 2 * (Math.cos(3.141592653589793 * t / d) - 1) + b;
  332.    }
  333.    static function easeOutInSine(t, b, c, d)
  334.    {
  335.       if((t /= d / 2) < 1)
  336.       {
  337.          return c / 2 * Math.sin(3.141592653589793 * t / 2) + b;
  338.       }
  339.       return (- c) / 2 * (Math.cos(3.141592653589793 * (t = t - 1) / 2) - 2) + b;
  340.    }
  341.    static function easeInCirc(t, b, c, d)
  342.    {
  343.       return (- c) * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
  344.    }
  345.    static function easeOutCirc(t, b, c, d)
  346.    {
  347.       return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;
  348.    }
  349.    static function easeInOutCirc(t, b, c, d)
  350.    {
  351.       if((t /= d / 2) < 1)
  352.       {
  353.          return (- c) / 2 * (Math.sqrt(1 - t * t) - 1) + b;
  354.       }
  355.       return c / 2 * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;
  356.    }
  357.    static function easeOutInCirc(t, b, c, d)
  358.    {
  359.       if((t /= d / 2) < 1)
  360.       {
  361.          return c / 2 * Math.sqrt(1 - (t = t - 1) * t) + b;
  362.       }
  363.       return c / 2 * (2 - Math.sqrt(1 - (t = t - 1) * t)) + b;
  364.    }
  365. }
  366.